package Dominio.Fachada;

import Dominio.Entidades.*;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;

public class Escalera implements Serializable {
    //Atributos

    private int numeroJugada = 0;
    private ArrayList<Jugador> listaJugadores;
    private ArrayList<Partida> listaPartidas;
    private Partida partida;
    //private IEscalera sistema;

    //Constructor por defecto
    public Escalera() {
        listaJugadores = new ArrayList<Jugador>();
        listaPartidas = new ArrayList<Partida>();
    }
//
//    public static Escalera getInstanciaSistema() {
//        return FEscaleraHolder.INSTANCE;
//    }
//
//    private static class FEscaleraHolder {
//
//        private static final Escalera INSTANCE = new Escalera();
//    }

    public ArrayList<Jugador> getListaDeJugadores() {
        return listaJugadores;
    }

    public ArrayList<Partida> getListaDepartidas() {
        return listaPartidas;
    }

    public Partida getPartida() {
        return partida;
    }

    //Método que agrega un socio a la lista de socios
    public void agregarJugador(Jugador pJugador) {
        this.getListaDeJugadores().add(pJugador);
    }

    //Método que agrega un trámite a la lista de trámites
    public void agregarPartida(Partida pPartida) {
        this.getListaDepartidas().add(pPartida);
    }

    //Método que agrega una solicitud a la lista de solicitudes
    public void agregarJugada(Jugada pJugada) throws Exception {
        numeroJugada += 1;
        
        pJugada.setNumero(numeroJugada);
        this.getPartida().agregarJugada(pJugada);
    }

    public Jugador crearJugador(String pNombre, String pAlias, int pEdad) {
        Jugador unJ = new Jugador(pNombre, pAlias, pEdad);
        return unJ;
    }

    public void updateJugador(Jugador unJugador, String alias, String nombre, int edad) {
        unJugador.setAlias(alias);
        unJugador.setNombre(nombre);
        unJugador.setEdad(edad);

    }

    public void borarJugador(Jugador unJugador) {
        this.listaJugadores.remove(unJugador);
    }

    public Partida crearPartida(String pBlanco, String pNegro, int pDimenciones, int pCantidadL, int pCantidadJugadas) {
        this.numeroJugada = 0;
        Celda[][] unT = new Celda[pDimenciones][pDimenciones];

        Jugador blanco = selectJugadorPartida(pBlanco);
        Jugador negro = selectJugadorPartida(pNegro);
        this.partida = new Partida(blanco, negro, unT, pCantidadL, pCantidadJugadas);
        return this.partida;
    }

    /**
     * Crea una jugada de ingreso de ficha y le define el nivel en el que
     * ingresa la pieza.
     *
     * @param pPartida
     * @param pTipo
     * @param pMovimientos
     * @param pIngresa
     * @return
     */
    public Jugada crearJugadaI(String pMovimientos) throws Exception {
        Jugada retorno = null;
        int nivelIngreso = 0;
        Jugada ultimaJugadaDeFicha = null;

        if (!this.getPartida().tieneDisponibleIngresarPieza(TipoPieza.Ficha)) {
            throw new Exception("El usuario ya tiene su ficha jugada.");
        }
        if (!this.getPartida().pudeIngresarOMoverFicha()) {
            throw new Exception("No hay jugadas posibles para ingesar su ficha.");
        }

        //Creo la jugada con los datos ingresados por el jugador de turno
        retorno = new Jugada(this.getPartida().turnoJugador(), null, pMovimientos, true);

        //Creo la pieza luego de de haber convertido los movimientos de la jugada
        Coordenada[] ubicacion = {retorno.getMovimientos()[retorno.getMovimientos().length - 1]};
        if (ubicacion.length > 1) {
            throw new Exception("El ingreso de ficha no puede tener mas de una coordenada");
        }
        Pieza unaP = crearPieza(TipoPieza.Ficha, ubicacion);
        unaP.setFicha(this.getPartida().textoFichaJugador());
        unaP.setTipo(TipoPieza.Ficha);
        retorno.setPieza(unaP);

        //Cargo el nivel donde quedara la pieza jugada.
        nivelIngreso = this.getPartida().calcularNivelIngreso(retorno);
        retorno.setNivel(nivelIngreso);

        retorno = validacionesIngresoFicha(retorno);
        return retorno;
    }

    /**
     * Crea una jugada de ingreso de ficha y le define el nivel en el que
     * ingresa la pieza.
     *
     * @param pPartida
     * @param pTipo
     * @param pMovimientos
     * @param pIngresa
     * @return
     */
    public Jugada crearJugadaI(Coordenada[] pMovimientos) throws Exception {
        Jugada retorno = null;
        int nivelIngreso = 0;
        Jugada ultimaJugadaDeFicha = null;

        if (!this.getPartida().tieneDisponibleIngresarPieza(TipoPieza.Ficha)) {
            throw new Exception("El usuario ya tiene su ficha jugada.");
        }
        if (!this.getPartida().pudeIngresarOMoverFicha()) {
            throw new Exception("No hay jugadas posibles para ingesar su ficha.");
        }

        //Creo la jugada con los datos ingresados por el jugador de turno
        retorno = new Jugada(this.getPartida().turnoJugador(), null, pMovimientos, 0, true);

        //Creo la pieza luego de de haber convertido los movimientos de la jugada
        Coordenada[] ubicacion = {retorno.getMovimientos()[retorno.getMovimientos().length - 1]};
        if (ubicacion.length > 1) {
            throw new Exception("El ingreso de ficha no puede tener mas de una coordenada");
        }
        Pieza unaP = crearPieza(TipoPieza.Ficha, ubicacion);
        unaP.setFicha(this.getPartida().textoFichaJugador());
        unaP.setTipo(TipoPieza.Ficha);
        retorno.setPieza(unaP);

        //Cargo el nivel donde quedara la pieza jugada.
        nivelIngreso = this.getPartida().calcularNivelIngreso(retorno);
        retorno.setNivel(nivelIngreso);

        retorno = validacionesIngresoFicha(retorno);
        return retorno;
    }

    /**
     * Crea una jugada de movimiento de ficha y le define el nivel en el que
     * ingresa la pieza.
     *
     * @param pPartida
     * @param pTipo
     * @param pMovimientos
     * @param pIngresa
     * @return
     */
    public Jugada crearJugadaM(String pMovimientos) throws Exception {
        Jugada retorno = null;
        try {
            int nivelIngreso = 0;
            Jugada ultimaJugadaDeFicha = null;

            if (this.getPartida().tieneDisponibleIngresarPieza(TipoPieza.Ficha)) {
                throw new Exception("El usuario no ha ingresado su ficha.");
            }
            if (!this.getPartida().pudeIngresarOMoverFicha()) {
                throw new Exception("No hay jugadas posibles para mover su ficha.");
            }

            //Creo la jugada con los datos ingresados por el jugador de turno
            retorno = new Jugada(this.getPartida().turnoJugador(), null, pMovimientos, true);

            //Creo la pieza luego de de haber convertido los movimientos de la jugada
            Coordenada[] ubicacion = {retorno.getMovimientos()[retorno.getMovimientos().length - 1]};
            Pieza unaP = crearPieza(TipoPieza.Ficha, ubicacion);
            unaP.setFicha(this.getPartida().textoFichaJugador());
            unaP.setTipo(TipoPieza.Ficha);
            retorno.setPieza(unaP);

            //Cargo el nivel donde quedara la pieza jugada.
            nivelIngreso = this.getPartida().calcularNivelIngreso(retorno);
            retorno.setNivel(nivelIngreso);

            retorno.setMueve(true);

            retorno = validacionesMoverFicha(retorno);
        } catch (Exception ex) {
            throw ex;
        }
        return retorno;
    }

    /**
     * Crea una jugada de movimiento de ficha y le define el nivel en el que
     * ingresa la pieza.
     *
     * @param pPartida
     * @param pTipo
     * @param pMovimientos
     * @param pIngresa
     * @return
     */
    public Jugada crearJugadaM(Coordenada[] pMovimientos) throws Exception {
        Jugada retorno = null;
        try {
            int nivelIngreso = 0;
            Jugada ultimaJugadaDeFicha = null;

            if (this.getPartida().tieneDisponibleIngresarPieza(TipoPieza.Ficha)) {
                throw new Exception("El usuario no ha ingresado su ficha.");
            }
            if (!this.getPartida().pudeIngresarOMoverFicha()) {
                throw new Exception("No hay jugadas posibles para mover su ficha.");
            }

            //Creo la jugada con los datos ingresados por el jugador de turno
            retorno = new Jugada(this.getPartida().turnoJugador(), null, pMovimientos, 0, true);

            //Creo la pieza luego de de haber convertido los movimientos de la jugada
            Coordenada[] ubicacion = {retorno.getMovimientos()[retorno.getMovimientos().length - 1]};
            Pieza unaP = crearPieza(TipoPieza.Ficha, ubicacion);
            unaP.setFicha(this.getPartida().textoFichaJugador());
            unaP.setTipo(TipoPieza.Ficha);
            retorno.setPieza(unaP);

            //Cargo el nivel donde quedara la pieza jugada.
            nivelIngreso = this.getPartida().calcularNivelIngreso(retorno);
            retorno.setNivel(nivelIngreso);

            retorno.setMueve(true);

            retorno = validacionesMoverFicha(retorno);
        } catch (Exception ex) {
            throw ex;
        }
        return retorno;
    }

    /**
     * Crea una jugada poner ladrillo y le define el nivel en el que ingresa la
     * pieza.
     *
     * @param pPartida
     * @param pTipo
     * @param pMovimientos
     * @param pIngresa
     * @return
     */
    public Jugada crearJugadaP(TipoPieza pTipo, String pMovimientos) throws Exception {
        Jugada retorno = null;
        try {
            boolean ingresa = false;
            int nivelIngreso = 0;
            Jugada ultimaJugadaDeFicha = null;

            //Creo la jugada con los datos ingresados por el jugador de turno
            retorno = new Jugada(this.getPartida().turnoJugador(), null, pMovimientos, true);

            //Creo la pieza luego de de haber convertido los movimientos de la jugada
            Coordenada[] ubicacion = retorno.getMovimientos();
            Pieza unaP = crearPieza(pTipo, ubicacion);
            if (ubicacion.length == 1) {

                if (!this.getPartida().tieneDisponibleIngresarPieza(TipoPieza.Cuadrado)) {
                    throw new Exception("El usuario no tiene disponible cuadrados para poner.");
                }
                unaP.setTipo(TipoPieza.Cuadrado);
            } else if (ubicacion.length == 2) {

                if (!this.getPartida().tieneDisponibleIngresarPieza(TipoPieza.Rectangulo)) {
                    throw new Exception("El usuario no tiene disponible rectangulos para poner.");
                }
                unaP.setTipo(TipoPieza.Rectangulo);
            } else {

                if (!this.getPartida().tieneDisponibleIngresarPieza(TipoPieza.LadrilloL)) {
                    throw new Exception("El usuario no tiene disponible ladrillos L para poner.");
                }
                unaP.setTipo(TipoPieza.LadrilloL);
            }
            retorno.setPieza(unaP);

            //Cargo el nivel donde quedara la pieza jugada.
            nivelIngreso = this.getPartida().calcularNivelIngreso(retorno);
            retorno.setNivel(nivelIngreso + 1);
            //Verficar que las coordenadas formen una de estas tres piezas: Cuadrado, Rectangulo, Ladrillo L           
            validacionPonerLadrillo(retorno);
        } catch (Exception ex) {
            throw ex;
        }
        return retorno;
    }

    /**
     * Crea una jugada poner ladrillo y le define el nivel en el que ingresa la
     * pieza.
     *
     * @param pPartida
     * @param pTipo
     * @param pMovimientos
     * @param pIngresa
     * @return
     */
    public Jugada crearJugadaP(TipoPieza pTipo, Coordenada[] pMovimientos) throws Exception {
        Jugada retorno = null;
        try {
            boolean ingresa = false;
            int nivelIngreso = 0;
            Jugada ultimaJugadaDeFicha = null;

            //Creo la jugada con los datos ingresados por el jugador de turno
            retorno = new Jugada(this.getPartida().turnoJugador(), null, pMovimientos, 0, true);

            //Creo la pieza luego de de haber convertido los movimientos de la jugada
            Coordenada[] ubicacion = retorno.getMovimientos();
            Pieza unaP = crearPieza(pTipo, ubicacion);
            if (ubicacion.length == 1) {

                if (!this.getPartida().tieneDisponibleIngresarPieza(TipoPieza.Cuadrado)) {
                    throw new Exception("El usuario no tiene disponible cuadrados para poner.");
                }
                unaP.setTipo(TipoPieza.Cuadrado);
            } else if (ubicacion.length == 2) {

                if (!this.getPartida().tieneDisponibleIngresarPieza(TipoPieza.Rectangulo)) {
                    throw new Exception("El usuario no tiene disponible rectangulos para poner.");
                }
                unaP.setTipo(TipoPieza.Rectangulo);
            } else {

                if (!this.getPartida().tieneDisponibleIngresarPieza(TipoPieza.LadrilloL)) {
                    throw new Exception("El usuario no tiene disponible ladrillos L para poner.");
                }
                unaP.setTipo(TipoPieza.LadrilloL);
            }
            retorno.setPieza(unaP);
            //Cargo el nivel donde quedara la pieza jugada.
            nivelIngreso = this.getPartida().calcularNivelIngreso(retorno);
            retorno.setNivel(nivelIngreso + 1);
            //Verficar que las coordenadas formen una de estas tres piezas: Cuadrado, Rectangulo, Ladrillo L
            validacionPonerLadrillo(retorno);
        } catch (Exception ex) {
            throw ex;
        }
        return retorno;
    }

    /**
     * Crea una jugada retirar ficha y le define el nivel en el que ingresa la
     * pieza.
     *
     * @param pPartida
     * @param pTipo
     * @param pMovimientos
     * @param pIngresa
     * @return
     */
    public Jugada crearJugadaR(TipoPieza pTipo) throws Exception {
        Jugada retorno = null;
        try {
            int nivelIngreso = 0;
            Jugada ultimaJugadaDeFicha = null;

            //Creo la jugada con los datos ingresados por el jugador de turno
            retorno = new Jugada(this.getPartida().turnoJugador(), null, null, false);


            //Obtengo la ultima posicion donde estuvo la ficha del jugador
            ultimaJugadaDeFicha = this.getPartida().ultimaJugadaDeSuFicha(retorno.getJugador());
            //Si la ficha del jugadro esta no esta en el tablero o fue retirada.
            if (!(ultimaJugadaDeFicha != null && ultimaJugadaDeFicha.isIngresa())) {
                throw new Exception("La ficha no se encuentra en el tablero.");
            } else {

                //Creo la pieza luego de de haber convertido los movimientos de la jugada
                Pieza unaP = crearPieza(pTipo, ultimaJugadaDeFicha.getPieza().getUbicacion());
                unaP.setFicha(this.getPartida().textoFichaJugador());
                unaP.setTipo(TipoPieza.Ficha);
                retorno.setPieza(unaP);

                retorno.setNivel(ultimaJugadaDeFicha.getNivel());

            }
        } catch (Exception ex) {
            throw ex;
        }
        return retorno;
    }

    /**
     * Verificar que cada movimiento sea horizontal o vertical. Verificar que
     * cada movimiento sea en un nivel ascendente, que ninguna de las
     * coordenadas de movimiento este la ficha del adversario.
     *
     * @param pJugada
     * @return
     * @throws Exception
     */
    private Jugada validacionesIngresoFicha(Jugada pJugada) throws Exception {
        boolean ingresa = false;
        Jugada ultimaJugadaDeFicha = null;
        Jugada ultimaJugadaDeFichaContraria = null;
        try {

            //Obtengo la ultima posicion donde estuvo la ficha del jugador
            ultimaJugadaDeFicha = this.getPartida().ultimaJugadaDeSuFicha(pJugada.getJugador());
            ultimaJugadaDeFichaContraria = this.getPartida().ultimaJugadaDeFichaContraria(pJugada.getJugador());
            //Si la ficha del jugadro no
            if (ultimaJugadaDeFichaContraria != null && ultimaJugadaDeFichaContraria.isIngresa()
                    && pJugada.getPieza().getUbicacion()[0].equals(ultimaJugadaDeFichaContraria.getPieza().getUbicacion()[0])) {
                throw new Exception("Esta intentando ingresar su ficha sobre la del contrario.");
            } else {
                if (ultimaJugadaDeFicha == null) {
                    if (pJugada.getNivel() == 0) {
                        ingresa = true;
                    } else {
                        throw new Exception("El primer ingreso de la ficha debe de ser en el nivel 0.");
                    }
                } else {
                    if (!ultimaJugadaDeFicha.isIngresa()) {
                        //Si el primer movimiento contiguo a la ultima posicion, orgotonal y en 
                        if (ultimaJugadaDeFicha.getNivel() == pJugada.getNivel()) {
                            ingresa = true;
                        } else {
                            throw new Exception("Para reingresar la ficha lo debe de hacer en el nivel " + ultimaJugadaDeFicha.getNivel() + ".");
                        }
                    } else {
                        throw new Exception("Para mover una ficha que esta en el trablero ingrese una jugada de movimiento.");
                    }
                }
            }
            if (!ingresa) {
                pJugada = null;
            }
        } catch (Exception ex) {
            throw ex;
        }
        return pJugada;
    }

    /**
     * Verificar que cada movimiento sea horizontal o vertical. Verificar que
     * cada movimiento sea en un nivel ascendente, que ninguna de las
     * coordenadas de movimiento este la ficha del adversario.
     *
     * @param pJugada
     * @return
     * @throws Exception
     */
    private Jugada validacionesMoverFicha(Jugada pJugada) throws Exception {
        boolean ingresa = false;
        Jugada ultimaJugadaDeFicha;
        try {

            //Obtengo la ultima posicion donde estuvo la ficha del jugador
            ultimaJugadaDeFicha = this.getPartida().ultimaJugadaDeSuFicha(pJugada.getJugador());
            //Si la ficha del jugadro no
            if (ultimaJugadaDeFicha != null && ultimaJugadaDeFicha.isIngresa()) {

                //Verificar que cada movimiento sea horizontal o vertical.
                //Verificar que cada movimiento sea en un nivel ascendente,
                if (this.getPartida().verificarMovimientosOrtogonales(pJugada)) {

                    //que ninguna de las coordenadas de movimiento este la ficha del adversario.
                    if (this.getPartida().validarNoPasarSobreFichaContraria(pJugada)) {

                        //Verifico que la haya una base de ladrillos en el nivel anterior
                        if (this.getPartida().validarBaseIngresoLadrillo(pJugada)) {

                            //Si el primer movimiento contiguo a la ultima posicion, orgotonal y en 
                            if (((ultimaJugadaDeFicha.getPieza().getUbicacion()[0].getPosFila() == pJugada.getMovimientos()[0].getPosFila()
                                    && ultimaJugadaDeFicha.getPieza().getUbicacion()[0].getPosColumna() == pJugada.getMovimientos()[0].getPosColumna() - 1)
                                    || (ultimaJugadaDeFicha.getPieza().getUbicacion()[0].getPosFila() == pJugada.getMovimientos()[0].getPosFila()
                                    && ultimaJugadaDeFicha.getPieza().getUbicacion()[0].getPosColumna() == pJugada.getMovimientos()[0].getPosColumna() + 1))
                                    || ((ultimaJugadaDeFicha.getPieza().getUbicacion()[0].getPosColumna() == pJugada.getMovimientos()[0].getPosColumna()
                                    && ultimaJugadaDeFicha.getPieza().getUbicacion()[0].getPosFila() == pJugada.getMovimientos()[0].getPosFila() - 1)
                                    || (ultimaJugadaDeFicha.getPieza().getUbicacion()[0].getPosColumna() == pJugada.getMovimientos()[0].getPosColumna()
                                    && ultimaJugadaDeFicha.getPieza().getUbicacion()[0].getPosFila() == pJugada.getMovimientos()[0].getPosFila() + 1))) //Si la ficha del jugadro fue retirada en un movimiento anterior
                            {
                                if (this.getPartida().movimientosAscDes(pJugada, ultimaJugadaDeFicha.getNivel())) {
                                    ingresa = true;
                                } else {
                                    throw new Exception("Se asciende o desciende de a un nivel.");
                                }
                            }
                        } else {
                            throw new Exception("Los lugares que ocupa la pieza a colocar no estan cubiertos en el nivel anterior.");
                        }
                    } else {
                        throw new Exception("No puede pasar por encima de la ficha de su oponente.");
                    }
                } else {
                    throw new Exception("Los movimientos no son ortogonales.");
                }
            } else {
                throw new Exception("La ficha no se encuentra en el tablero.");
            }
            if (!ingresa) {
                pJugada = null;
            }
        } catch (Exception ex) {
            throw ex;
        }
        return pJugada;
    }

    /**
     * Verficar que la pieza no se coloque sobre una ficha Verificar que se
     * ingrese resocstadoa a otro ladrillo si no es el primero en el nivel
     * Verificar que en el nivel anterior exista una base de ladrillos diferente
     * a el que ingresa
     *
     * @param retorno
     * @throws Exception
     */
    private void validacionPonerLadrillo(Jugada retorno) throws Exception {
        try {
            //Que no sea sobre una ficha
            if (this.getPartida().validarPiezaNoSobreFicha(retorno)) {
                //Si es la primer jugada de ladrillo   , no entro
                if (!this.getPartida().primerLadrillo(retorno)) {
                    //Si en el nivel anterios no hay otro ladrillo igual en las mismas coordenadas
                    //Si no hay espacios vacios en el nivel anterior.
                    if (this.getPartida().validarBaseIngresoLadrillo(retorno)) {
                        //Si uno de sus lados esta en contacto con otro ladrillo
                        if (!this.getPartida().validarCaraConLadrillo(retorno)) {
                            throw new Exception("El ladrillo ingresado no tiene lado en común con ningún  ladrillo del tablero.");
                        }
                    } else {
                        throw new Exception("Los lugares que ocupa la pieza a colocar no estan cobiertos en el nivel anterior.");
                    }
                } else {
                    if (retorno.getNivel() > 1) {
                        //Si en el nivel anterios no hay otro ladrillo igual en las mismas coordenadas
                        //Si no hay espacios vacios en el nivel anterior.
                        if (!this.getPartida().validarBaseIngresoLadrillo(retorno)) {
//                        //Si uno de sus lados esta en contacto con otro ladrillo
//                        if (!pPartida.validarCaraConLadrillo(retorno)) {
//                            throw new Exception("Los lugares que ocupa la pieza a colocar no estan cobiertos en el nivel anterior.");
//                        }
//                    } else {
                            throw new Exception("Los lugares que ocupa la pieza a colocar no estan cobiertos en el nivel anterior.");
                        }
                    }
                }
            } else {
                throw new Exception("No puede poner un larillo sobre una ficha.");
            }
        } catch (Exception ex) {
            throw ex;
        }
    }

    /**
     * Verifica el estado de la partida, determinando si es posible continual el
     * juego 1- no es posible poner mas ladrillos y un jugador no pued colocar
     * ni mover su ficha 2- se realizaron la cantidad maxima prestablecida de
     * jugadas
     *
     * @param pPartida
     * @return
     */
    public boolean finalDeLaPartida(boolean pFinalizar) throws Exception {
        boolean finalizo = false;
        try {
            finalizo = this.getPartida().finalDeLaPartida(pFinalizar);
        } catch (Exception ex) {
            throw ex;
        }
        return finalizo;
    }

    /**
     * Verifica el estado de la partida, determinando si es posible continual el
     * juego 1- no es posible poner mas ladrillos y un jugador no pued colocar
     * ni mover su ficha 2- se realizaron la cantidad maxima prestablecida de
     * jugadas
     *
     * @param pPartida
     * @return
     */
    public String resultadoDeLaPartida() throws Exception {
        String finalizo = null;
        try {
            finalizo = this.getPartida().resultadoDeLaPartida();
        } catch (Exception ex) {
            throw ex;
        }
        return finalizo;
    }

    private Pieza crearPieza(TipoPieza pTipo, Coordenada[] pMovimientos) throws Exception {

        Pieza unPieza = new Pieza(pTipo, pMovimientos);
        unPieza.movimientosValidos();
        return unPieza;
    }
    //Método que verifica si existe o no el socio

    public boolean existeJugador(String pAlias) {
        Jugador unJ = new Jugador();
        unJ.setAlias(pAlias);
        return this.getListaDeJugadores().contains(unJ);
    }

    //Método que retorna un jugador buscado por su alias
    private Jugador selectJugadorPartida(String pAlias) {
        Jugador unJ = new Jugador();
        unJ.setAlias(pAlias);
        Jugador jSelect = new Jugador();
        boolean validador = false;

        for (int i = 0; i < this.listaJugadores.size(); i++) {
            if (unJ.equals(this.listaJugadores.get(i))) {
                jSelect = this.listaJugadores.get(i);
            }
        }


        return jSelect;
    }

    /**
     * Método que arma un array de Jugadores por puntaje ------Ver-----
     *
     * @return
     */
    public ArrayList<Jugador> rankingJugadores() {
        Collections.sort(this.listaJugadores);
        return this.listaJugadores;
    }

    /**
     * Dependiendo de quien sea el turno si se abandona la partida perdera.
     *
     * @param pPartida
     * @return
     */
    public void abandonarPartida() {
        this.getPartida().abandonar();
    }

    //Método que arma un array de Jugadores por puntaje ------Ver-----
    public ArrayList<Jugador> maxiomosPuntajes() {
        ArrayList<Jugador> solicitudAux = new ArrayList<Jugador>();
        Iterator<Jugador> it = this.getListaDeJugadores().iterator();

        while (it.hasNext()) {
            Jugador unJ = it.next();
            /*if (unJ.getNombre()) {
             solicitudAux.add(unaSolicitud);
             }*/
        }
        return solicitudAux;
    }
}
